home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 15 / BBS in a box XV-2.iso / Files II / Prog / B-C / B-YACC.sit / berkeley-yacc-mpw / test / error.tab.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-10-14  |  6.2 KB  |  268 lines  |  [TEXT/MPS ]
  1. #ifndef lint
  2. char yysccsid[] = "@(#)yaccpar    1.3 (Berkeley) 01/21/90";
  3. #endif
  4. #define YYERRCODE 256
  5. short yylhs[] = {                                        -1,
  6.     0,
  7. };
  8. short yylen[] = {                                         2,
  9.     1,
  10. };
  11. short yydefred[] = {                                      0,
  12.     1,    0,
  13. };
  14. short yydgoto[] = {                                       2,
  15. };
  16. short yysindex[] = {                                   -256,
  17.     0,    0,
  18. };
  19. short yyrindex[] = {                                      0,
  20.     0,    0,
  21. };
  22. short yygindex[] = {                                      0,
  23. };
  24. #define YYTABLESIZE 0
  25. short yytable[] = {                                       1,
  26. };
  27. short yycheck[] = {                                     256,
  28. };
  29. #define YYFINAL 2
  30. #ifndef YYDEBUG
  31. #define YYDEBUG 0
  32. #endif
  33. #define YYMAXTOKEN 0
  34. #if YYDEBUG
  35. char *yyname[] = {
  36. "end-of-file",
  37. };
  38. char *yyrule[] = {
  39. "$accept : S",
  40. "S : error",
  41. };
  42. #endif
  43. #ifndef YYSTYPE
  44. typedef int YYSTYPE;
  45. #endif
  46. #define yyclearin (yychar=(-1))
  47. #define yyerrok (yyerrflag=0)
  48. #ifndef YYSTACKSIZE
  49. #ifdef YYMAXDEPTH
  50. #define YYSTACKSIZE YYMAXDEPTH
  51. #else
  52. #define YYSTACKSIZE 300
  53. #endif
  54. #endif
  55. int yydebug;
  56. int yynerrs;
  57. int yyerrflag;
  58. int yychar;
  59. short *yyssp;
  60. YYSTYPE *yyvsp;
  61. YYSTYPE yyval;
  62. YYSTYPE yylval;
  63. #define yystacksize YYSTACKSIZE
  64. short yyss[YYSTACKSIZE];
  65. YYSTYPE yyvs[YYSTACKSIZE];
  66. #line 4 "error.y"
  67. main(){printf("yyparse() = %d\n",yyparse());}
  68. yylex(){return-1;}
  69. yyerror(s)char*s;{printf("%s\n",s);}
  70. #line 70 "error.tab.c"
  71. #define YYABORT goto yyabort
  72. #define YYACCEPT goto yyaccept
  73. #define YYERROR goto yyerrlab
  74. int
  75. yyparse()
  76. {
  77.     register int yym, yyn, yystate;
  78. #if YYDEBUG
  79.     register char *yys;
  80.     extern char *getenv();
  81.  
  82.     if (yys = getenv("YYDEBUG"))
  83.     {
  84.         yyn = *yys;
  85.         if (yyn == '0')
  86.             yydebug = 0;
  87.         else if (yyn >= '1' && yyn <= '9')
  88.             yydebug = yyn - '0';
  89.     }
  90. #endif
  91.  
  92.     yynerrs = 0;
  93.     yyerrflag = 0;
  94.     yychar = (-1);
  95.  
  96.     yyssp = yyss;
  97.     yyvsp = yyvs;
  98.     *yyssp = yystate = 0;
  99.  
  100. yyloop:
  101.     if (yyn = yydefred[yystate]) goto yyreduce;
  102.     if (yychar < 0)
  103.     {
  104.         if ((yychar = yylex()) < 0) yychar = 0;
  105. #if YYDEBUG
  106.         if (yydebug)
  107.         {
  108.             yys = 0;
  109.             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  110.             if (!yys) yys = "illegal-symbol";
  111.             printf("yydebug: state %d, reading %d (%s)\n", yystate,
  112.                     yychar, yys);
  113.         }
  114. #endif
  115.     }
  116.     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
  117.             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
  118.     {
  119. #if YYDEBUG
  120.         if (yydebug)
  121.             printf("yydebug: state %d, shifting to state %d\n",
  122.                     yystate, yytable[yyn]);
  123. #endif
  124.         if (yyssp >= yyss + yystacksize - 1)
  125.         {
  126.             goto yyoverflow;
  127.         }
  128.         *++yyssp = yystate = yytable[yyn];
  129.         *++yyvsp = yylval;
  130.         yychar = (-1);
  131.         if (yyerrflag > 0)  --yyerrflag;
  132.         goto yyloop;
  133.     }
  134.     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
  135.             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
  136.     {
  137.         yyn = yytable[yyn];
  138.         goto yyreduce;
  139.     }
  140.     if (yyerrflag) goto yyinrecovery;
  141. #ifdef lint
  142.     goto yynewerror;
  143. #endif
  144. yynewerror:
  145.     yyerror("syntax error");
  146. #ifdef lint
  147.     goto yyerrlab;
  148. #endif
  149. yyerrlab:
  150.     ++yynerrs;
  151. yyinrecovery:
  152.     if (yyerrflag < 3)
  153.     {
  154.         yyerrflag = 3;
  155.         for (;;)
  156.         {
  157.             if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
  158.                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
  159.             {
  160. #if YYDEBUG
  161.                 if (yydebug)
  162.                     printf("yydebug: state %d, error recovery shifting\
  163.  to state %d\n", *yyssp, yytable[yyn]);
  164. #endif
  165.                 if (yyssp >= yyss + yystacksize - 1)
  166.                 {
  167.                     goto yyoverflow;
  168.                 }
  169.                 *++yyssp = yystate = yytable[yyn];
  170.                 *++yyvsp = yylval;
  171.                 goto yyloop;
  172.             }
  173.             else
  174.             {
  175. #if YYDEBUG
  176.                 if (yydebug)
  177.                     printf("yydebug: error recovery discarding state %d\n",
  178.                             *yyssp);
  179. #endif
  180.                 if (yyssp <= yyss) goto yyabort;
  181.                 --yyssp;
  182.                 --yyvsp;
  183.             }
  184.         }
  185.     }
  186.     else
  187.     {
  188.         if (yychar == 0) goto yyabort;
  189. #if YYDEBUG
  190.         if (yydebug)
  191.         {
  192.             yys = 0;
  193.             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  194.             if (!yys) yys = "illegal-symbol";
  195.             printf("yydebug: state %d, error recovery discards token %d (%s)\n",
  196.                     yystate, yychar, yys);
  197.         }
  198. #endif
  199.         yychar = (-1);
  200.         goto yyloop;
  201.     }
  202. yyreduce:
  203. #if YYDEBUG
  204.     if (yydebug)
  205.         printf("yydebug: state %d, reducing by rule %d (%s)\n",
  206.                 yystate, yyn, yyrule[yyn]);
  207. #endif
  208.     yym = yylen[yyn];
  209.     yyval = yyvsp[1-yym];
  210.     switch (yyn)
  211.     {
  212.     }
  213.     yyssp -= yym;
  214.     yystate = *yyssp;
  215.     yyvsp -= yym;
  216.     yym = yylhs[yyn];
  217.     if (yystate == 0 && yym == 0)
  218.     {
  219. #ifdef YYDEBUG
  220.         if (yydebug)
  221.             printf("yydebug: after reduction, shifting from state 0 to\
  222.  state %d\n", YYFINAL);
  223. #endif
  224.         yystate = YYFINAL;
  225.         *++yyssp = YYFINAL;
  226.         *++yyvsp = yyval;
  227.         if (yychar < 0)
  228.         {
  229.             if ((yychar = yylex()) < 0) yychar = 0;
  230. #if YYDEBUG
  231.             if (yydebug)
  232.             {
  233.                 yys = 0;
  234.                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  235.                 if (!yys) yys = "illegal-symbol";
  236.                 printf("yydebug: state %d, reading %d (%s)\n",
  237.                         YYFINAL, yychar, yys);
  238.             }
  239. #endif
  240.         }
  241.         if (yychar == 0) goto yyaccept;
  242.         goto yyloop;
  243.     }
  244.     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
  245.             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
  246.         yystate = yytable[yyn];
  247.     else
  248.         yystate = yydgoto[yym];
  249. #ifdef YYDEBUG
  250.     if (yydebug)
  251.         printf("yydebug: after reduction, shifting from state %d \
  252. to state %d\n", *yyssp, yystate);
  253. #endif
  254.     if (yyssp >= yyss + yystacksize - 1)
  255.     {
  256.         goto yyoverflow;
  257.     }
  258.     *++yyssp = yystate;
  259.     *++yyvsp = yyval;
  260.     goto yyloop;
  261. yyoverflow:
  262.     yyerror("yacc stack overflow");
  263. yyabort:
  264.     return (1);
  265. yyaccept:
  266.     return (0);
  267. }
  268.